import { Item, DataEquip } from "../shared/face/index";
import { ItemType } from "../shared/face/enums";
import { BaseBody, player } from '../core/rpg';
import { ComType } from '../core/tool/component';
import { analysisIntent } from '../core/tool/baseScene';
import bag_component from '../component/bag_component';
import gameCfg from '../gameCfg';
import { ButtonIntentConfig } from '../core/tool/Icard';
import { mathType } from '../core/tool/face';
import { BaseService } from './BaseService';
import base_component from '../component/base_component';
import { bagFuncs, BagFuncName, BagFuncResult } from './bagFunc';
import { ModernBaseService } from './base/ModernBaseService';
import { ModernBagService } from './ModernBagService';
import { DIContainer } from '../infrastructure/di';

/**
 * 背包服务类 - 兼容性包装器
 * 职责：
 * 1. 为旧代码提供兼容性支持
 * 2. 将调用转发到ModernBagService
 * 3. 数据格式转换
 * 4. 逐步迁移到新架构
 */
export class BagService extends ModernBaseService {
    private modernBagService: ModernBagService;

    constructor(container?: DIContainer) {
        super(container);
        this.modernBagService = new ModernBagService(container);
    }

    /**
     * 服务初始化
     */
    protected async onInit(): Promise<void> {
        await this.modernBagService.init();
        this.log('BagService (compatibility wrapper) initialized');
    }

    /**
     * 服务销毁
     */
    protected async onDestroy(): Promise<void> {
        await this.modernBagService.destroy();
        this.log('BagService (compatibility wrapper) destroyed');
    }

    /**
     * 添加道具到背包 (兼容性方法)
     * @param bagItems 背包物品列表 (已废弃，仅为兼容性保留)
     * @param item 要添加的物品
     * @param maxSize 背包最大容量 (已废弃，仅为兼容性保留)
     * @returns 添加结果
     * @deprecated 请使用 modernBagService.addItem 替代
     */
    addItem(bagItems: Item[], item: Item, maxSize: number = 200): {
        success: boolean;
        message: string;
        newBagItems: Item[];
        addedCount: number;
    } {
        // 兼容性实现 - 直接处理数组操作
        const newBagItems = [...bagItems];
        let addedCount = 0;

        // 检查背包容量
        if (newBagItems.length >= maxSize) {
            return {
                success: false,
                message: '背包已满',
                newBagItems: bagItems,
                addedCount: 0
            };
        }

        // 如果物品可以堆叠，查找相同物品
        if (item.stacking) {
            const existingIndex = newBagItems.findIndex(bagItem =>
                bagItem.id === item.id && bagItem.type === item.type
            );

            if (existingIndex !== -1) {
                // 叠加相同物品
                newBagItems[existingIndex].count += item.count;
                addedCount = item.count;
            } else {
                // 添加新物品
                newBagItems.push({ ...item });
                addedCount = item.count;
            }
        } else {
            // 不能堆叠的物品，每个都作为独立物品添加
            if (item.count > 1) {
                // 如果数量大于1，创建多个独立物品
                for (let i = 0; i < item.count; i++) {
                    const singleItem = { ...item, count: 1 };
                    newBagItems.push(singleItem);
                }
                addedCount = item.count;
            } else {
                // 单个物品
                newBagItems.push({ ...item });
                addedCount = item.count;
            }
        }

        return {
            success: true,
            message: `获得 ${item.name} x${addedCount}`,
            newBagItems,
            addedCount
        };
    }

    /**
     * 添加物品到玩家背包 (现代化方法)
     * @param playerId 玩家ID
     * @param itemConfig 物品配置
     * @returns 添加结果
     */
    async addItemToPlayer(playerId: string, itemConfig: any): Promise<any> {
        try {
            return await this.modernBagService.addItem(playerId, itemConfig);
        } catch (error) {
            return this.handleBusinessError(error, 'addItemToPlayer');
        }
    }

    /**
     * 从背包中移除道具
     * @param bagItems 背包物品列表
     * @param item 要移除的物品
     * @param count 移除数量
     * @returns 移除结果
     */
    removeItem(bagItems: Item[], item: Item, count: number): {
        success: boolean;
        message: string;
        newBagItems: Item[];
    } {
        const newBagItems = [...bagItems];
        
        // 如果物品可以堆叠，查找相同物品
        if (item.stacking) {
            const index = newBagItems.findIndex(bagItem =>
                bagItem.id === item.id && bagItem.type === item.type
            );

            if (index === -1) {
                return {
                    success: false,
                    message: '道具不存在',
                    newBagItems: bagItems
                };
            }

            const bagItem = newBagItems[index];
            if (bagItem.count < count) {
                return {
                    success: false,
                    message: '道具数量不足',
                    newBagItems: bagItems
                };
            }

            bagItem.count -= count;
            if (bagItem.count === 0) {
                newBagItems.splice(index, 1);
            }

            return {
                success: true,
                message: `移除 ${item.name} x${count}`,
                newBagItems
            };
        } else {
            // 不能堆叠的物品，需要移除指定数量的独立物品
            let remainingCount = count;
            const itemsToRemove: number[] = [];
            
            // 找到所有匹配的物品
            for (let i = 0; i < newBagItems.length && remainingCount > 0; i++) {
                const bagItem = newBagItems[i];
                if (bagItem.id === item.id && bagItem.type === item.type) {
                    itemsToRemove.push(i);
                    remainingCount--;
                }
            }
            
            if (itemsToRemove.length < count) {
                return {
                    success: false,
                    message: '道具数量不足',
                    newBagItems: bagItems
                };
            }
            
            // 从后往前移除，避免索引变化
            for (let i = itemsToRemove.length - 1; i >= 0; i--) {
                newBagItems.splice(itemsToRemove[i], 1);
            }
            
            return {
                success: true,
                message: `移除 ${item.name} x${count}`,
                newBagItems
            };
        }
    }

    /**
     * 使用道具
     * @param bagItems 背包物品列表
     * @param itemIndex 道具索引
     * @param count 使用数量
     * @returns 使用结果
     */
    useItem(bagItems: Item[], itemIndex: number, count: number): {
        success: boolean;
        message: string;
        newBagItems: Item[];
        usedItem: Item;
        actionType: 'equip' | 'pet'  | 'resource' | 'consumable' | 'none';
        actionData?: any;
        count: number;
    } {
        if (itemIndex < 0 || itemIndex >= bagItems.length) {
            return {
                success: false,
                message: '道具不存在',
                count: 0,
                newBagItems: bagItems,
                usedItem: bagItems[itemIndex],
                actionType: 'none',
                actionData: undefined
            };
        }

        const newBagItems = [...bagItems];
        const item = newBagItems[itemIndex];

        if (item.count < count) {
            count = item.count;
        }
        if(item.stacking_use){
            count = 1;
        }

        // 消耗道具
        if (item.stacking) {
            // 可堆叠物品，减少数量
            item.count -= count;
            if (item.count === 0) {
                newBagItems.splice(itemIndex, 1);
            }
        } else {
            // 不可堆叠物品，需要移除指定数量的物品
            let remainingCount = count;
            const itemsToRemove: number[] = [];
            
            // 找到所有匹配的物品
            for (let i = 0; i < newBagItems.length && remainingCount > 0; i++) {
                const bagItem = newBagItems[i];
                if (bagItem.id === item.id && bagItem.type === item.type) {
                    itemsToRemove.push(i);
                    remainingCount--;
                }
            }
            
            if (itemsToRemove.length < count) {
                return {
                    success: false,
                    message: '道具数量不足',
                    newBagItems: bagItems,
                    usedItem: item,
                    actionType: 'none',
                    actionData: undefined,
                    count: 0
                };
            }
            
            // 从后往前移除，避免索引变化
            for (let i = itemsToRemove.length - 1; i >= 0; i--) {
                newBagItems.splice(itemsToRemove[i], 1);
            }
        }

        // 根据道具类型返回不同的动作
        let actionType: 'equip' | 'resource' | 'consumable' | 'none' = 'none';
        let actionData: any = undefined;
        let message = '';

        switch (item.type) {
            case ItemType.装备:
                actionType = 'equip';
                actionData = item.data;
                message = `使用装备: ${item.name}`;
                break;
            case ItemType.资源:
                actionType = 'resource';
                actionData = item.data;
                message = `${item.name}无法直接使用`;
                break;
            case ItemType.消耗品:
                actionType = 'consumable';
                actionData = {
                    funcName: item.data.funcName,
                    funcData: item.data.funcData
                };
                message = `使用消耗品: ${item.name}`;
                break;
            default:
                message = `${item.name}无法使用`;
                break;
        }

        return {
            success: true,
            message,
            newBagItems,
            usedItem: item,
            actionType,
            actionData,
            count
        };
    }


    /**
     * 处理盲盒开启
     * @param boxData 盲盒数据
     * @param count 开启数量
     * @returns 盲盒奖励
     */
    openBox(boxData: any, count: number): {
        success: boolean;
        message: string;
        rewards: Item[];
    } {
        try {
            const rewards = this.sdk.prop.coverBoxGift(boxData, count);
            return {
                success: true,
                message: `开启盲盒获得 ${rewards.length} 个奖励`,
                rewards
            };
        } catch (error) {
            return {
                success: false,
                message: '开启盲盒失败',
                rewards: []
            };
        }
    }

    /**
     * 使用消耗品
     * @param useItem 使用的物品
     * @param useCount 使用数量
     * @param funcName 函数名
     * @param funcData 函数数据
     * @param _player 玩家对象
     * @returns 使用结果
     */
    async useConsumable(useItem: Item, useCount: number, funcName: string, funcData: any, _player: BaseBody): Promise<BagFuncResult> {

        try {
            // 检查函数是否存在
            if (!(funcName in bagFuncs)) {
                throw new Error(`未找到函数: ${funcName}`);
            }

            // 通过引用调用函数
            const func = bagFuncs[funcName as BagFuncName];
            const result = await func(useItem, useCount, funcData, _player);
            
            return result || {
                success: true,
                message: '消耗品使用成功',
                data: { action: funcName }
            };
        } catch (error: any) {
            console.error('消耗品使用失败:', error);
            return {
                success: false,
                message: '消耗品使用失败',
                data: { error: error.message }
            };
        }
    }



    /**
     * 整理背包
     * @param bagItems 背包物品列表
     * @returns 整理后的背包
     */
    sortBag(bagItems: Item[]): Item[] {
        const typeOrder = [
            ItemType.装备,
            ItemType.道具,
            ItemType.资源,
            ItemType.消耗品,
        ];

        return [...bagItems].sort((a, b) => {
            const aIndex = typeOrder.indexOf(a.type);
            const bIndex = typeOrder.indexOf(b.type);

            if (aIndex !== bIndex) {
                return aIndex - bIndex;
            }

            // 同类型按品质排序
            if (a.quality !== b.quality) {
                return b.quality - a.quality;
            }

            // 同品质按名称排序
            return a.name.localeCompare(b.name);
        });
    }


    /**
     * 检查背包是否有指定物品
     * @param bagItems 背包物品列表
     * @param itemId 物品ID
     * @param itemType 物品类型
     * @param requiredCount 需要的数量
     * @returns 是否有足够的物品
     */
    hasItem(bagItems: Item[], itemId: string, itemType: ItemType, requiredCount: number = 1): boolean {
        const matchingItems = bagItems.filter(bagItem =>
            bagItem.id === itemId && bagItem.type === itemType
        );

        if (matchingItems.length === 0) {
            return false;
        }

        // 如果第一个物品可以堆叠，检查总数量
        if (matchingItems[0].stacking) {
            const totalCount = matchingItems.reduce((sum, item) => sum + item.count, 0);
            return totalCount >= requiredCount;
        } else {
            // 不能堆叠的物品，检查独立物品数量
            return matchingItems.length >= requiredCount;
        }
    }

        /**
     * 查找背包中的物品 (兼容性方法)
     * @param bagItems 背包物品列表
     * @param itemId 物品ID
     * @param itemType 物品类型
     * @returns 找到的物品或null
     * @deprecated 请使用 modernBagService.findItem 替代
     */
    findItem(bagItems: Item[], itemId: string, itemType: ItemType): Item | null {
        const matchingItems = bagItems.filter(bagItem =>
            bagItem.id === itemId && bagItem.type === itemType
        );

        if (matchingItems.length === 0) {
            return null;
        }

        // 如果第一个物品可以堆叠，返回第一个匹配的物品
        if (matchingItems[0].stacking) {
            return matchingItems[0];
        } else {
            // 不能堆叠的物品，返回第一个匹配的物品
            return matchingItems[0];
        }
    }

    /**
     * 在玩家背包中查找物品 (现代化方法)
     * @param playerId 玩家ID
     * @param itemId 物品ID
     * @param itemType 物品类型
     * @returns 找到的物品实体
     */
    async findItemInPlayer(playerId: string, itemId: string, itemType?: ItemType): Promise<any> {
        try {
            return await this.modernBagService.findItem(playerId, itemId, itemType);
        } catch (error) {
            this.log(`Error finding item: ${(error as any).message}`, 'error');
            return null;
        }
    }

    /**
     * 获取玩家背包信息 (现代化方法)
     * @param playerId 玩家ID
     * @returns 背包信息
     */
    async getPlayerBagInfo(playerId: string): Promise<any> {
        try {
            return await this.modernBagService.getBagInfo(playerId);
        } catch (error) {
            return this.handleBusinessError(error, 'getPlayerBagInfo');
        }
    }

    /**
     * 使用物品 (现代化方法)
     * @param playerId 玩家ID
     * @param itemId 物品ID
     * @param count 使用数量
     * @returns 使用结果
     */
    async usePlayerItem(playerId: string, itemId: string, count: number = 1): Promise<any> {
        try {
            return await this.modernBagService.useItem(playerId, itemId, count);
        } catch (error) {
            return this.handleBusinessError(error, 'usePlayerItem');
        }
    }

    /**
     * 整理玩家背包 (现代化方法)
     * @param playerId 玩家ID
     * @returns 整理结果
     */
    async organizePlayerBag(playerId: string): Promise<any> {
        try {
            return await this.modernBagService.organizeBag(playerId);
        } catch (error) {
            return this.handleBusinessError(error, 'organizePlayerBag');
        }
    }

    /**
     * 获取现代化服务实例 (供直接访问)
     * @returns ModernBagService实例
     */
    getModernService(): ModernBagService {
        return this.modernBagService;
    }
}

// 使用适配器管理实例以保持向后兼容
import { LegacyServiceAdapter } from './base/LegacyServiceAdapter';
export const bagService = LegacyServiceAdapter.getInstance(BagService); 